export const 图片元素减后台 = (str, 后台基础路径) => {
	if (!str) return
	const regex = new RegExp(`(?<=<img [^>]*src=['"])(${后台基础路径})+(?=[^'"]+[^>]*>)`, 'g');
	str = str.replace(regex, '')
	return str
}

export const 图片元素加后台 = (str, 后台基础路径) => {
	if (!str) return
	str = str.replace(/<img [^>]*src=['"]([^'"]+)[^>]*>/g, (match, capture) => {
		// console.log('capture: ', capture);
		const 新 = 予图片路径(capture, 后台基础路径)
		// console.log('新: ', 新);
		return match.replace(capture, 新);
	});
	return str
}

export const 予图片路径 = (url, 后台基础路径) => {
	if (url && url.slice(0, 4) !== 'http') {
		if (后台基础路径 === "/") {
			return url
		}
		if (url.slice(0, 1) === "/") {
			return 后台基础路径 + url
		}
		return 后台基础路径 + "/" + url
	} else {
		return url
	}
}

export function cs() {
	console.log('cs ing🙋‍');
}
export function 对象重予(原对象, 新对象) {
	// 清空
	for (let key in 原对象) {
		if (原对象.hasOwnProperty(key)) {
			delete 原对象[key];
		}
	}
	Object.assign(原对象, 新对象)
}

export function 对象重新赋值废(原对象, 新对象) {
	// 清空
	// console.log('原对象: ', 原对象);
	// Object.keys(原对象).forEach((key) => {
	// 	console.log('对象重新赋值 原对象的 key: ', key);
	// 	delete 原对象[key]
	// });
	for (let key in 原对象) {
		if (原对象.hasOwnProperty(key)) {
			// console.log('对象重新赋值 hasOwnProperty 方式 原对象的 key: ', key);
			delete 原对象[key];
		}
	}
	// 把obj2的键赋予给obj1
	Object.keys(新对象).forEach((key) => {
		// console.log('重新赋值都有的 key: ', key);
		原对象[key] = 新对象[key];
	});
}

export function 对象重新赋值一精细控制一好像没必要(原对象, 新对象) {
	for (let key in 原对象) {
		if (原对象.hasOwnProperty(key)) {
			// console.log('对象重新赋值 hasOwnProperty 方式 原对象的 key: ', key);
			if (!Object.keys(新对象).includes(key)) {
				console.log('删除新对象中没有的 key: ', key);
				delete 原对象[key];
			}
		}
	}
	// 把obj2的键赋予给obj1
	Object.keys(新对象).forEach((key) => {
		// console.log('重新赋值都有的 key: ', key);
		// console.log('重新赋值都有的 原对象[key]: ', 原对象[key]);
		// console.log('重新赋值都有的 新对象[key]: ', 新对象[key]);
		if (isArray(原对象[key])) {
			数组重新赋值(原对象[key], 新对象[key])
		} else {
			原对象[key] = 新对象[key];
		}
		// 如果是对象呢？递归调用？……碰到再说
	});
}
export const isArray = value => Object.prototype.toString.call(value) === '[object Array]';

export function 加入属性(目标对象, 取值对象, 拟排除属性组 = ["id", "UpdatedAt", "DeletedAt", "CreatedAt"]) {
	取值对象 = 成对象_排除属性(取值对象, 拟排除属性组)
	for (const key in 取值对象) {
		目标对象[key] = 取值对象[key]
	}
}

export function 成对象_排除属性(obj, 拟排除属性组 = ["id", "UpdatedAt", "DeletedAt", "CreatedAt"]) {
	const newObj = {};
	for (let key in obj) {
		// 检查key是否不在排除的键数组中
		if (!拟排除属性组.includes(key)) {
			newObj[key] = obj[key];
		}
	}
	return newObj;
}

export function 排除部分对象属性(obj, 拟删除属性组 = ["id", "UpdatedAt", "DeletedAt", "CreatedAt"]) {
	const newObj = {};
	for (let key in obj) {
		// 检查key是否不在排除的键数组中
		if (!拟删除属性组.includes(key)) {
			newObj[key] = obj[key];
		}
	}
	return newObj;
}



export function 删除部分对象属性(原对象, 拟删除属性组) {
	拟删除属性组.forEach(拟删除属性 => {
		delete 原对象[拟删除属性];
	});
}

export function 分转元(req) {
	// let res = (req / 100).toFixed(1)
	let res = (req / 100)
	return res;
}

export function 格式化日期(date, format) {
	const year = date.getFullYear();
	const month = String(date.getMonth() + 1).padStart(2, '0');
	const day = String(date.getDate()).padStart(2, '0');
	const hours = String(date.getHours()).padStart(2, '0');
	const minutes = String(date.getMinutes()).padStart(2, '0');
	const seconds = String(date.getSeconds()).padStart(2, '0');
	// console.log('format: ', format);
	return format
		.replace('yyyy', year)
		.replace('MM', month)
		.replace('dd', day)
		.replace('HH', hours)
		.replace('mm', minutes)
		.replace('ss', seconds);
}

export function 获取数组中对象最大值(arr, 字段 = 'id') {
	let max = 0;
	if (arr.length != 0) {
		max = Math.max(...arr.map((item) => parseInt(item[字段])));
	}
	return max;
}

export function 深拷贝_全(target, map = new WeakMap()) {
    // 如果 target 是基本类型或者为 null，直接返回
    if (typeof target !== 'object' || target === null) {
        return target;
    }

    // 检查是否已经拷贝过该对象，避免循环引用
    if (map.has(target)) {
        return map.get(target);
    }

    let clone;
    if (Array.isArray(target)) {
        // 如果是数组，创建一个新数组
        clone = [];
        map.set(target, clone);
        // 递归拷贝数组元素
        target.forEach((item, index) => {
            clone[index] = 深拷贝_全(item, map);
        });
    } else if (target instanceof Date) {
        // 如果是日期对象，创建一个新的日期对象
        clone = new Date(target.getTime());
        map.set(target, clone);
    } else if (target instanceof RegExp) {
        // 如果是正则对象，创建一个新的正则对象
        clone = new RegExp(target);
        map.set(target, clone);
    } else {
        // 如果是普通对象，创建一个新对象
        clone = {};
        map.set(target, clone);
        // 递归拷贝对象属性
        for (const key in target) {
            if (target.hasOwnProperty(key)) {
                clone[key] = 深拷贝_全(target[key], map);
            }
        }
    }
    return clone;
}


export function 深拷贝(obj) {
	const obj1 = JSON.parse(JSON.stringify(obj))
	return obj1;
}

export function 累加(arr, 字段) {
	return arr.reduce((prev, next) => {
		return prev += Number(next[字段])
	}, 0)
}

export function 累加前几个(arr, 字段, 个数 = 7) {
	const res = arr.slice(0, 个数).reduce((acc, curr) => acc + (curr[字段] || 0), 0);
	return res
}

export function 含其中哪个(str, 关键词组) {
	let 含哪个 = ''
	// const 含 = 关键词组.some((item) => {
	// 	return str.includes(item);
	// });
	for (let item of 关键词组) {
		if (str.includes(item)) {
			含哪个 = item
			return 含哪个
		}
	}
	return 含哪个
}

export function 含其中之一(str, 关键词组) {
	// console.log('含其中之一 str: ', str);
	const 含 = 关键词组.some((item) => {
		// console.log('关键词: ', item);
		return str.includes(item);
	});
	// console.log('含: ', 含);
	return 含
}

export function 其中之一包含(arr, 关键词组) {
	const 含 = arr.some((item) => {
		const 某个关键词是否包含 = 关键词组.some((关键词) => {
			// console.log('关键词: ', 关键词);
			// console.log('item: ', item);
			return item.includes(关键词);
		});
		return 某个关键词是否包含
	});
	return 含
}

export function 都包含(arr, 关键词组) {
	const 含 = 关键词组.every((关键词) => {
		return arr.includes(关键词);
	});
	return 含
}

export function 正则匹配(str, 表达式) {
	// const 表达式 = `(\\d+)${替换组[0]}`
	// console.log('表达式: ', 表达式);
	const regexp = new RegExp(表达式, 'g');
	let match = regexp.test(str)
	return match;
}

export function 数字末尾字符替换(str, 替换组 = []) {
	const 表达式 = `(\\d+)${替换组[0]}`
	// console.log('表达式: ', 表达式);

	const numberRegex = new RegExp(表达式, 'g');
	let result = str;
	let match;
	while ((match = numberRegex.exec(result)) !== null) {
		let 原数字 = match[1];
		console.log('原数字: ', 原数字);
		result = result.replace(match[0], 原数字 + 替换组[1]);
	}
	return result;
}



export const 弹窗输入 = async (title, content, 点击确认 = () => { }) => {
	uni.showModal({
		editable: true,
		title,
		content,
		success: res => {
			if (res.confirm) {
				// console.log('res: ', res);
				点击确认(res);
				return res
			}
		}
	});
};

export const 弹窗 = (title, content, 点击确认 = () => { }) => {
	uni.showModal({
		title,
		content,
		success: res => {
			if (res.confirm) {
				点击确认();
				return res
			}
		}
	});
};